﻿using Library.AppWeb;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MPR.Poker.DALEntity.SYS;
using MPR.Poker.Model.SYS;

namespace MPR.Poker.DALEntity.SYS
{
    public class DAL_User
    {
        public DAL_User()
        {
        }

        #region Insert/Update/Delete

        /// <summary>
        /// Thêm mới người dùng tổng hợp
        /// </summary>
        /// <param name="objUser"></param>
        /// <returns></returns>
        public ResultMessage Insert(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                objResultMessage = CheckExist(objUser);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = InsertNoCheck(objUser);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật người dùng tổng hợp
        /// </summary>
        /// <param name="objUser"></param>
        /// <returns></returns>
        public ResultMessage Update(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                objResultMessage = CheckExist(objUser);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = UpdateNoCheck( objUser);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi cập nhật người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Xóa người dùng
        /// </summary>
        /// <param name="strUserID"></param>
        /// <returns></returns>
        public ResultMessage Delete(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            objResultMessage = CheckRelationship(objUser);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objUser);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa người dùng
        /// </summary>
        /// <param name="intUserIDSys">Mã người dùng</param>
        /// <param name="intDeletedUser">Mã người dùng</param>
        /// <returns></returns>
        public ResultMessage Delete(int intUserIDSys, int intDeletedUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User objUser = new SYS_User();
            objUser.IDSys = intUserIDSys;

            objResultMessage = CheckRelationship(objUser);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objUser);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa người dùng
        /// </summary>
        /// <param name="lstUserIDSys">List đối tượng người dùng</param>
        /// <param name="intDeletedUser">Mã người dùng</param>
        /// <returns></returns>
        public ResultMessage Delete(List<int> lstUserIDSys, int intDeletedUser)
        {
            ResultMessage objResultMessage = new ResultMessage();

            foreach (int IDSys in lstUserIDSys)
            {
                SYS_User objUser = new SYS_User();
                objUser.IDSys = IDSys;

                objResultMessage = CheckRelationship(objUser);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = DeleteNoCheck(objUser);
                if (objResultMessage.IsError) return objResultMessage;
            }

            return objResultMessage;
        }

        /// <summary>
        /// Kiềm tra tồn tại người dùng
        /// </summary>
        /// <param name="strID"></param>
        /// <param name="strUserID"></param>
        /// <returns></returns>
        public ResultMessage CheckExist(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User User = new SYS_User();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    User = db.SYS_Users.FirstOrDefault(i => i.IsDeleted == false & i.UserName == objUser.UserName & i.IDSys != objUser.IDSys);

                    if (User != null && User.UserName.Trim().Length > 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "người dùng đã tồn tại", string.Empty);
                    }
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra tồn tại người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> CheckExist");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Kiểm tra dữ liệu liên quan
        /// </summary>
        /// <param name="strUserID"></param>
        /// <returns></returns>
        public ResultMessage CheckRelationship(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                //using (PokerLife db = new PokerLife())
                //{
                //    SYS_User user = db.SYS_Users.FirstOrDefault(i => i.UserGroupIDSys == objUserGroup.IDSys);

                //    if (user != null && user.UID.Trim().Length > 0)
                //    {
                //        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.No_Error, "Có dữ liệu liên quan đến nhóm người dùng", string.Empty);
                //    }
                //}
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra dữ liệu liên quan người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> CheckRelationship");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Thêm mới người dùng không cần kiểm tra
        /// </summary>
        /// <param name="objUser"></param>
        /// <returns></returns>
        public ResultMessage InsertNoCheck(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User User = new SYS_User();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    User.UserName = objUser.UserName;
                    User.Password = Library.AppWeb.Cryptography.HashingMD5(objUser.Password);
                    
                    User.Note = objUser.Note;
                    User.IsActived = objUser.IsActived;
                    User.OrderIndex = db.SYS_Users.Count() + 1;


                    db.SYS_Users.Add(User);
                    db.SaveChanges();
                }
                objUser.IDSys = User.IDSys;
                objUser.UserName = User.UserName;
                DAL_Event.Insert("Thêm mới người dùng - " + User.UserName.ToString(), 0, ResultMessage.ErrorTypes.Insert.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật người dùng không cần kiểm tra
        /// </summary>
        /// <param name="objUser"></param>
        /// <returns></returns>
        public ResultMessage UpdateNoCheck(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    SYS_User User = db.SYS_Users.FirstOrDefault(i => i.IDSys == objUser.IDSys);
                    User.UserName = objUser.UserName;
                    User.Password = Library.AppWeb.Cryptography.HashingMD5(objUser.Password);
                    User.Note = objUser.Note;
                    User.IsActived = objUser.IsActived;

                    db.SaveChanges();
                }

                DAL_Event.Insert("Cập nhật người dùng - " + objUser.UserName.ToString(), 0, ResultMessage.ErrorTypes.Update.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Update, "Lỗi cập nhật người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Xóa người dùng không cần kiểm tra
        /// </summary>
        /// <param name="objUser"></param>
        /// <returns></returns>
        public ResultMessage DeleteNoCheck(SYS_User objUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    SYS_User User = db.SYS_Users.FirstOrDefault(i => i.IDSys == objUser.IDSys);
                    if (User == null || User.IDSys == 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "người dùng không tồn tại", string.Empty);
                        return objResultMessage;
                    }

                    User.IsDeleted = true;
                    User.DeletedDate = DateTime.Now;

                    db.SaveChanges();
                }

                DAL_Event.Insert("Xóa người dùng - " + objUser.UserName.ToString(), 0, ResultMessage.ErrorTypes.Delete.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Delete, "Lỗi xóa người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> DeleteNoCheck");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Xóa người dùng thành công", string.Empty);
        }
        
        /// <summary>
        /// Login
        /// </summary>
        /// <param name="strUserName"></param>
        /// <param name="strPass"></param>
        /// <returns></returns>
        public ResultMessage Login(string strUserName, string strPass)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User User = new SYS_User();

            try
            {
                strPass = Library.AppWeb.Cryptography.HashingMD5(strPass);
                using (PokerLife db = new PokerLife())
                {
                    User = db.SYS_Users.FirstOrDefault(i => i.UserName.Equals(strUserName) & i.Password.Equals(strPass) & i.IsActived == true & i.IsDeleted == false);
                    if (User == null || User.IDSys == 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Người dùng không tồn tại", string.Empty);
                        return objResultMessage;
                    }
                }

                //DAL_Event.Insert("Login - " + User.UserName.ToString(), User.IDSys, ResultMessage.ErrorTypes.Login.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Login, "Login phát sinh lỗi", objEx);
                DAL_Error.Insert(objResultMessage, User.IDSys, "DAL_User --> Login");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Login thành công", string.Empty);
        }

        /// <summary>
        /// Login
        /// </summary>
        /// <param name="objUser">Đối tượng User</param>
        /// <param name="strUserName"></param>
        /// <param name="strPass"></param>
        /// <returns></returns>
        public ResultMessage Login(ref SYS_User objUser, string strUserName, string strPass)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User User = new SYS_User();
            
            try
            {
                strPass = Library.AppWeb.Cryptography.HashingMD5(strPass);
                using (PokerLife db = new PokerLife())
                {
                    User = db.SYS_Users.FirstOrDefault(i => i.UserName.Equals(strUserName) & i.Password.Equals(strPass) & i.IsActived == true & i.IsDeleted == false);
                    if (User == null || User.IDSys == 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Người dùng không tồn tại", string.Empty);
                        return objResultMessage;
                    }

                    objUser = User;
                }

                //DAL_Event.Insert("Login - " + User.UserName.ToString(), User.IDSys, ResultMessage.ErrorTypes.Login.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Login, "Login phát sinh lỗi", objEx);
                DAL_Error.Insert(objResultMessage, User.IDSys, "DAL_User --> Login");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Login thành công", string.Empty);
        }

        /// <summary>
        /// Login
        /// </summary>
        /// <param name="objSessionUser">Đối tượng SessionUser</param>
        /// <param name="strUserName"></param>
        /// <param name="strPass"></param>
        /// <returns></returns>
        //public ResultMessage Login(ref SessionUser objSessionUser, string strUserName, string strPass)
        //{
        //    ResultMessage objResultMessage = new ResultMessage();
        //    SYS_User User = new SYS_User();
        //    SYS_UserBranch UserBranch = new SYS_UserBranch();

        //    try
        //    {
        //        strPass = Library.AppWeb.Cryptography.HashingMD5(strPass);
        //        using (PokerLife db = new PokerLife())
        //        {
        //            User = db.SYS_Users.FirstOrDefault(i => i.UserName.Equals(strUserName) & i.Password.Equals(strPass) & i.IsActived == true & i.IsDeleted == false);
        //            if (User == null || User.IDSys == 0)
        //            {
        //                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Người dùng không tồn tại", string.Empty);
        //                return objResultMessage;
        //            }

        //            SessionUser obj = new SessionUser();
        //            obj.UserIDSys = User.IDSys;
        //            obj.UserName = User.UserName;
        //            obj.UserGroupIDSys = User.UserGroupIDSys;
        //            obj.Password = User.Password;
        //            obj.EmployessIDSys = User.EmployeeIDSys;
        //            obj.BranchIDSys = UserBranch.BranchIDSys;
        //            obj.BranchID = UserBranch.BranchID;
        //            obj.BranchName = UserBranch.BranchName;
        //            objSessionUser = obj;
        //        }

        //        DAL_Event.Insert("Login - " + User.UserName.ToString(), User.IDSys, ResultMessage.ErrorTypes.Login.ToString());

        //    }
        //    catch (Exception objEx)
        //    {
        //        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Login, "Login phát sinh lỗi", objEx);
        //        DAL_Error.Insert(objResultMessage, User.IDSys, "DAL_User --> Login");
        //        return objResultMessage;
        //    }
        //    return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Login thành công", string.Empty);
        //}

        public ResultMessage Logout(string strUserName, string strPass, int intBranchIDSys)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_User User = new SYS_User();
            
            try
            {
                strPass = Library.AppWeb.Cryptography.HashingMD5(strPass);
                using (PokerLife db = new PokerLife())
                {
                    User = db.SYS_Users.FirstOrDefault(i => i.UserName.Equals(strUserName) & i.Password.Equals(strPass));
                    if (User == null || User.IDSys == 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Người dùng không tồn tại", string.Empty);
                        return objResultMessage;
                    }

                   
                }

                //DAL_Event.Insert("Logout - " + User.UserName.ToString() + " - " + intBranchIDSys.ToString(), User.IDSys, ResultMessage.ErrorTypes.Logout.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Logout, "Logout phát sinh lỗi", objEx);
                DAL_Error.Insert(objResultMessage, User.IDSys, "DAL_User --> Logout");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Logout thành công", string.Empty);
        }

        #endregion

        #region Load/Search/Select

        /// <summary>
        /// Lấy thông tin người dùng
        /// </summary>
        /// <param name="objUser"></param>
        /// <param name="strID"></param>
        /// <returns></returns>
        public ResultMessage LoadInfo(ref SYS_User objUser, int intUserIDSys)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var User = from gu in db.SYS_Users
                               where gu.IDSys == intUserIDSys
                               select gu;
                    objUser = new SYS_User();
                    foreach (var obj in User)
                    {
                        if (!Convert.IsDBNull(obj.IDSys)) objUser.IDSys = obj.IDSys;
                        if (!string.IsNullOrEmpty(obj.UserName)) objUser.UserName = obj.UserName;
                        if (!string.IsNullOrEmpty(obj.Password)) objUser.Password = obj.Password;
                        if (!string.IsNullOrEmpty(obj.Note)) objUser.Note = obj.Note;
                        if (!Convert.IsDBNull(obj.IsActived)) objUser.IsActived = obj.IsActived;
                        if (!Convert.IsDBNull(obj.OrderIndex)) objUser.OrderIndex = obj.OrderIndex;
                        if (!Convert.IsDBNull(obj.IsDeleted)) objUser.IsDeleted = obj.IsDeleted;
                        if (!Convert.IsDBNull(obj.DeletedDate)) objUser.DeletedDate = obj.DeletedDate;
                    }
                }

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.LoadInfo, "Lấy thông tin người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> LoadInfo");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy thông tin người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách người dùng
        /// </summary>
        /// <param name="dtUser"></param>
        /// <returns></returns>
        public ResultMessage SearchData(ref DataTable dtUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            dtUser = new DataTable();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    dtUser = ConvertData.ConvertToDataTable<SYS_User>(db.SYS_Users.Where(i => i.IsDeleted == false).ToList());
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SearchData, "Lấy thông tin người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> LoadInfo");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách người dùng dạng List
        /// </summary>
        /// <param name="lstUser"></param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_User> lstUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var User = from gu in db.SYS_Users
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;
                    lstUser = User.ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách người dùng dạng List
        /// </summary>
        /// <param name="lstUser">Đối tượng người dùng</param>
        /// <param name="intPageSize">Số lượng Record một trang</param>
        /// <param name="intPageNumber">Lấy trang số mấy</param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_User> lstUser, int intPageSize, int intPageNumber)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var User = from gu in db.SYS_Users
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;

                    lstUser = User.Skip((intPageNumber - 1) * intPageSize).Take(intPageSize).ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách người dùng để Cache
        /// </summary>
        /// <param name="lstUser"></param>
        /// <returns></returns>
        public ResultMessage SelectToCache(ref List<SYS_User> lstUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {

                    IEnumerable<SYS_User> User = (from gu in db.SYS_Users
                                                  where gu.IsDeleted == false
                                                  orderby gu.OrderIndex
                                                  select new
                                                  {
                                                      IDSys = gu.IDSys,
                                                      UserName = gu.UserName,
                                                      Note = gu.Note,
                                                      gu.IsActived,
                                                      OrderIndex = (Nullable<int>)gu.OrderIndex == null ? 0 : gu.OrderIndex
                                                  }).ToList().Select(c => new SYS_User()
                                                  {
                                                      IDSys = c.IDSys,
                                                      UserName = c.UserName,
                                                      Note = c.Note,
                                                      IsActived = c.IsActived,
                                                      OrderIndex = (Nullable<int>)c.OrderIndex == null ? 0 : 0
                                                  });

                    lstUser = User.ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy Cache danh sách người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_User --> SelectToListCache");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách người dùng thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách người dùng từ Cache
        /// </summary>
        /// <param name="lstUser"></param>
        /// <returns></returns>
        public ResultMessage SelectToListCache(ref List<SYS_User> lstUser)
        {
            ResultMessage objResultMessage = new ResultMessage();
            objResultMessage = MPR.Poker.DALEntity.DataCache.GetDataCache.GetUser(ref lstUser);
            return objResultMessage;
        }

        #endregion
    }
}
